﻿#define _CRT_SECURE_NO_WARNINGS 1

//类型转换
//C++⽀持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。
//构造函数前⾯加explicit就不再⽀持隐式类型转换。
//类类型的对象之间也可以隐式转换，需要相应的构造函数⽀持

#include <iostream>
using namespace std;

class A
{
public:
	/*explicit A(int a1)*/
	A(int a1)
	    :_a1(a1)
	{}

	A(const A& aa)
		:_a1(aa._a1)
		,_a2(aa._a2)
	{}
	explicit A(int a1, int a2)
		:_a1(a1)
		,_a2(a2)
	{}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}

	int Get() const
	{
		return _a1 + _a2;
	}

private:
	int _a1 = 1;
	int _a2 = 2;
};


//int main()
//{
//	//自定义类型对象 = 内置类型对象  （隐式转换）
//	A aa1(1);
//	A aa2(1, 1);
//
//	A aa3 = 1;//会调用对应的构造函数
//	const A& aa4 = 5;   //1首先生成一个临时对象，再将临时对象拷贝给aa4  由于临时对象具有常性，这里使用引用接收时前面要加const 否则权限放大
//
//
//	A aa5 = { 2,2 };//二元类型的转换
//	const A& aa6 = { 2,2 };
//
//	//类型转换的意义
//
//	/*Stack st;
//	A aa7(7);
//	st.Push(aa7);*/    //在之前如果想要在栈中插入一个类对象 需要先定义一个实例化的对象
//
//	/*A aa8(8, 8);
//	st.Push(aa8);*/
//
//	//如果在栈中定义好类型转换的构造函数后  就可以按如下操作
//	/*st.Push(7);
//	st.Push({8, 8});*/
//
//	return 0;
//}

class B
{
public:
	B(const A& a)
		:_b(a.Get())
	{}
private:
	int _b = 0;
};

class Stack
{
public:
	void Push(const A& aa)
	{}
};

int main()
{
	int c = 1;
	A aa3 = c;  //int类型的变量c隐式转换为

	A aa1(1);  //这里不是一个类型转换 就是一个普通的调用构造函数
	B bb1 = aa1; //调试观察发现bb1的值是3即1+2 即对应构造函数中的a.Get（）

	const B& bb2 = aa1;  

	// 整形之间，整形和浮点数之间，整形和指针，指针和指针之间
	int i = 0;
	double d = i;
	const double& rd = i;

	return 0;
}
